const GAMEOBJECTS = []
let isPaused = false

export class GameObject {
    constructor() {
        GAMEOBJECTS.push(this)
        //当前帧距离上一帧的时间间隔
        this.timedelta = 0
        this.hasStarted = false
        this._destroyed = false
    }

    // 静态方法，用于获取所有游戏对象
    static getObjects() {
        return GAMEOBJECTS
    }
// 静态方法，用于暂停游戏
    static pause_game() {
        isPaused = true
    }

    // 静态方法，用于恢复游戏
    static resume_game() {
        isPaused = false
    }

    // 静态方法，获取游戏暂停状态
    static is_game_paused() {
        return isPaused
    }
  // 静态方法，重置所有游戏对象
    static reset_game_objects() {
        // 创建副本以避免在遍历过程中修改原数组
        const objectsToDestroy = [...GAMEOBJECTS]

        // 销毁所有游戏对象
        objectsToDestroy.forEach((obj) => {
            obj.destroy()
        })

        // 确保数组已清空
       GAMEOBJECTS.length = 0

        // 重置暂停状态
        isPaused = false
    }

    // 静态方法，用于清理所有游戏对象
    static clearAll() {
        if (GAMEOBJECTS.length > 0) {
            console.log(`清理 ${GAMEOBJECTS.length} 个游戏对象`);
            try {
                // 创建副本进行操作，避免迭代时修改数组导致问题
                const objectsCopy = [...GAMEOBJECTS];
                
                // 首先尝试清除引用，减少销毁时的循环依赖问题
                objectsCopy.forEach(obj => {
                    if (obj && !obj._destroyed && typeof obj._clearReferences === 'function') {
                        try {
                            obj._clearReferences();
                        } catch (e) {
                            console.warn(`清理对象引用时出错`);
                        }
                    }
                });
                
                // 然后销毁所有对象
                objectsCopy.forEach(obj => {
                    if (obj && !obj._destroyed) {
                        try {
                            obj.destroy();
                        } catch (e) {
                            // 确保即使出错也标记为已销毁
                            obj._destroyed = true;
                            // 从数组中移除
                            const index = GAMEOBJECTS.indexOf(obj);
                            if (index !== -1) {
                                GAMEOBJECTS.splice(index, 1);
                            }
                        }
                    }
                });
                
                // 确保数组被清空
                GAMEOBJECTS.length = 0;
            } catch (error) {
                console.error("清理游戏对象时发生严重错误:", error);
                // 出现严重错误时，强制清空数组
                GAMEOBJECTS.length = 0;
            }
        }
    }

    start() {}

    update() {}

    on_destroy() {}

    destroy() {
        // 防止重复调用destroy
        if (this._destroyed) return;
        
        // 立即标记为已销毁，防止递归调用
        this._destroyed = true;
        
        try {
            // 移除对象与其他对象的引用关系
            this._clearReferences();
            
            // 调用子类的清理方法
            if (typeof this.on_destroy === 'function') {
                this.on_destroy();
            }
        } catch (e) {
            console.warn('对象销毁过程中出错:', e);
        } finally {
            // 确保从全局对象列表中移除，即使发生错误
            try {
                const index = GAMEOBJECTS.indexOf(this);
                if (index !== -1) {
                    GAMEOBJECTS.splice(index, 1);
                }
            } catch (e) {
                console.error('从游戏对象列表移除对象时出错:', e);
            }
        }
    }
    
    // 清除对象的引用关系
    _clearReferences() {
        // 获取所有属性，处理引用关系
        for (let key in this) {
            // 跳过内置属性和方法
            if (key === '_destroyed' || key === 'destroy' || key === 'on_destroy' || 
                key === '_clearReferences' || key === 'constructor' || typeof this[key] === 'function') {
                continue;
            }
            
            try {
                // 安全地移除指向GameObject对象的引用
                if (this[key] && typeof this[key] === 'object') {
                    if (this[key] instanceof GameObject) {
                        // 如果引用的是另一个游戏对象，只解除引用而不销毁它
                        this[key] = null;
                    } else if (Array.isArray(this[key])) {
                        // 处理数组 - 解除对游戏对象的引用
                        for (let i = 0; i < this[key].length; i++) {
                            if (this[key][i] instanceof GameObject) {
                                this[key][i] = null;
                            }
                        }
                    }
                }
            } catch (e) {
                console.warn(`清理属性 ${key} 时出错:`, e);
            }
        }
    }
}

//用于存储上一帧的时间戳
let lastTimestamp

const step = (timestamp) => {
    if (isPaused) {
        lastTimestamp = timestamp
        requestAnimationFrame(step)
        return
    }
    for (let obj of GAMEOBJECTS) {
        if (!obj.hasStarted) {
            obj.start()
            obj.hasStarted = true
        } else {
            obj.timedelta = timestamp - lastTimestamp
            obj.update()
        }
    }
    //更新上一帧的时间戳为当前时间戳
    lastTimestamp = timestamp

    requestAnimationFrame(step)
}

requestAnimationFrame(step)
